home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / scope / 076-100 / scopedisk86 / maze12 / source / maze.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-19  |  36.0 KB  |  1,144 lines
  1. #include <exec/types.h>
  2. #include <intuition/intuition.h>
  3. #include <functions.h>
  4. #include <graphics/gfxmacros.h>
  5. #include <graphics/text.h>
  6. struct IntuitionBase *IntuitionBase;
  7. struct GfxBase       *GfxBase;
  8.  
  9. struct RastPort  tmpRPactual;
  10. struct RastPort *tmpRP = &tmpRPactual;
  11. struct BitMap    tmpBM;
  12.  
  13. struct TextAttr font = {
  14.         (STRPTR)"topaz.font",   /* Font Name */
  15.         TOPAZ_EIGHTY,    /* Font Height */
  16.         FS_NORMAL,      /* Font Style */
  17.         FPF_ROMFONT     /* Preferences */
  18.         };
  19.  
  20. #define tmpBMxy 60L
  21.  
  22. #define windowW 552L
  23. #define windowH 183L
  24.  
  25. struct NewWindow nw = {
  26.       6, 12, windowW, windowH,      /* EDGES, SIZE */
  27.       0, 1,                         /* PENS */
  28.       CLOSEWINDOW,                  /* IDCMPFlags */
  29.       WINDOWDRAG  | WINDOWDEPTH |   /* Flags (requested window features)*/
  30.         WINDOWCLOSE | ACTIVATE | REPORTMOUSE,
  31.       NULL,                         /* gadgets */
  32.       NULL,                         /* checkmark image */
  33.       NULL,                         /* title */
  34.       NULL,                         /* screen */
  35.       NULL,                         /* bitmap */
  36.       0,0,0,0,                      /* min and max w and h */
  37.       WBENCHSCREEN,                 /* TYPE */
  38.       };
  39.  
  40.  
  41. struct IntuiText it_GiveUp = {
  42.         0,1,        /* frontpen, backpen */
  43.         JAM1,       /* drawmode */
  44.         1,1,        /* leftedge, topedge */
  45.         &font,       /* TextAttr * ITextFont */
  46.         (UBYTE *)" Give Up! ",  /* IText */
  47.         NULL,       /* NextText */
  48.         };
  49. struct MenuItem mi_GiveUp = {
  50.         (struct MenuItem *) NULL,
  51.         0,40,                        /* LeftEdge, TopEdge */
  52.         21*9,10,                    /* Width, Height */
  53.         ITEMTEXT | HIGHCOMP | ITEMENABLED,        /* Flags */
  54.         0,                          /* Mutual Exclude */
  55.         (APTR)&it_GiveUp,           /* ItemFill */
  56.         NULL,                       /* SelectFill */
  57.         0,                          /* Command    */
  58.         NULL,                       /* Subitem */
  59.         0,                          /* NextSelect */
  60.         };
  61.  
  62. struct IntuiText it_3Level = {
  63.         0,1,        /* frontpen, backpen */
  64.         JAM1,       /* drawmode */
  65.         1,1,        /* leftedge, topedge */
  66.         &font,       /* TextAttr * ITextFont */
  67.         (UBYTE *)"New 3-Level Maze",  /* IText */
  68.         NULL,       /* NextText */
  69.         };
  70. struct MenuItem mi_3Level = {
  71.         (struct MenuItem *) &mi_GiveUp,
  72.         0,30,                        /* LeftEdge, TopEdge */
  73.         21*9,10,                    /* Width, Height */
  74.         ITEMTEXT | HIGHCOMP | ITEMENABLED,        /* Flags */
  75.         0,                          /* Mutual Exclude */
  76.         (APTR)&it_3Level,           /* ItemFill */
  77.         NULL,                       /* SelectFill */
  78.         0,                          /* Command    */
  79.         NULL,                       /* Subitem */
  80.         0,                          /* NextSelect */
  81.         };
  82.  
  83. struct IntuiText it_2Level = {
  84.         0,1,        /* frontpen, backpen */
  85.         JAM1,       /* drawmode */
  86.         1,1,        /* leftedge, topedge */
  87.         &font,       /* TextAttr * ITextFont */
  88.         (UBYTE *)"New 2-Level Maze",  /* IText */
  89.         NULL,       /* NextText */
  90.         };
  91. struct MenuItem mi_2Level = {
  92.         (struct MenuItem *) &mi_3Level,
  93.         0,20,                      /* LeftEdge, TopEdge */
  94.         21*9,10,                    /* Width, Height */
  95.         ITEMTEXT | HIGHCOMP | ITEMENABLED,        /* Flags */
  96.         0,                          /* Mutual Exclude */
  97.         (APTR)&it_2Level,           /* ItemFill */
  98.         NULL,                       /* SelectFill */
  99.         0,                          /* Command    */
  100.         NULL,                       /* Subitem */
  101.         0,                          /* NextSelect */
  102.         };
  103. struct IntuiText it_1Level = {
  104.         0,1,        /* frontpen, backpen */
  105.         JAM1,       /* drawmode */
  106.         1,1,        /* leftedge, topedge */
  107.         &font,       /* TextAttr * ITextFont */
  108.         (UBYTE *)"New 1-Level Maze",  /* IText */
  109.         NULL,       /* NextText */
  110.         };
  111. struct MenuItem mi_1Level = {
  112.         (struct MenuItem *)&mi_2Level,
  113.         0,10,                      /* LeftEdge, TopEdge */
  114.         21*9,10,                    /* Width, Height */
  115.         ITEMTEXT | HIGHCOMP | ITEMENABLED,        /* Flags */
  116.         0,                          /* Mutual Exclude */
  117.         (APTR)&it_1Level,            /* ItemFill */
  118.         NULL,                       /* SelectFill */
  119.         0,                          /* Command    */
  120.         NULL,                       /* Subitem */
  121.         0,                          /* NextSelect */
  122.         };
  123.  
  124. struct IntuiText it_About = {
  125.         0,1,        /* frontpen, backpen */
  126.         JAM1,       /* drawmode */
  127.         1,1,        /* leftedge, topedge */
  128.         &font,       /* TextAttr * ITextFont */
  129.         (UBYTE *)"About TML's AmigaMaze",  /* IText */
  130.         NULL,      /* NextText */
  131.         };
  132. struct MenuItem mi_About = {
  133.         (struct MenuItem *) &mi_1Level,
  134.         0,0,                      /* LeftEdge, TopEdge */
  135.         21*9,10,                    /* Width, Height */
  136.         ITEMTEXT | HIGHCOMP | ITEMENABLED,        /* Flags */
  137.         0,                          /* Mutual Exclude */
  138.         (APTR)&it_About,            /* ItemFill */
  139.         NULL,                       /* SelectFill */
  140.         0,                          /* Command    */
  141.         NULL,                       /* Subitem */
  142.         0,                         /* NextSelect */
  143.         };
  144. struct Menu menu = {
  145.         (struct Menu *) NULL,    /* NEXT menu */
  146.         0, 0, 12*9, 0,           /* LeftEdge, TopEdge, Width, Height */
  147.         MENUENABLED,             /* Flags */
  148.         (BYTE *) "Maze Control", /* MenuName */
  149.         (struct MenuItem *)&mi_About,            /* First item */
  150.         0,0,0,0,                /* JazzX,JazzY, BeatX, BeatY */
  151.         };
  152.  
  153. struct Window *window;
  154.  
  155. /* BEWARE: NOWHERE has a dual nature, being used as a doesn't-go-anywhere
  156.    indicator, and also as an invalid level marker!!!   */
  157. #define NOWHERE -1
  158. #define SOUTH    0
  159. #define EAST     1
  160. #define WEST     2
  161. #define NORTH    3
  162.  
  163. #define SOLVED   -3
  164.  
  165. #define DIRECTIONS 4
  166. #define MAXLEVELS  3
  167. #define BOARDMAXX 36
  168. #define BOARDMAXY 29
  169. /*** the following are "inpath" stata. (see struct square) *******/
  170. #define NOTTRAVERSED  1
  171. #define EDGE          2
  172. #define LASTPIECE     3 + 32
  173. #define FIRSTPIECE    3 + 64
  174. #define CURPIECE      3 + 96
  175. #define TRAVERSED     3
  176.  
  177. #define MIDCMP1 CLOSEWINDOW|MOUSEMOVE|MOUSEBUTTONS|MENUPICK|MENUVERIFY
  178. #define MIDCMP2 REQCLEAR
  179. #define MIDCMP3 CLOSEWINDOW
  180.  
  181. extern ULONG RangeRand();
  182. extern int about();
  183. extern int cycle();
  184.  
  185. typedef struct {
  186.        int conlev[ DIRECTIONS ]; /** level connected to in each dir. **/
  187.        int inpath;  /** Also the color this should be drawn in.  **/
  188.        int compass; /** Which direction to go to get home from here **/
  189.        } square;
  190.  
  191. typedef square BOARD[ BOARDMAXX+1 ][ BOARDMAXY+1 ][ MAXLEVELS ];
  192.  
  193. BOARD board;
  194.  
  195. struct RastPort *rp;
  196.  
  197. int StartX, StartY, StartLevel;
  198. int EndX,   EndY,   EndLevel;
  199.  
  200. int CurX,   CurY,   CurLevel;
  201. int NewX,   NewY,   NewLevel;
  202. int MouseX, MouseY;
  203. int MinLevel, MaxLevel;
  204. int BoardMaxX = BOARDMAXX;
  205. int BoardMaxY = BOARDMAXY;
  206. int SquareXsize = 34;
  207. int SquareYsize = 18;
  208.  
  209. /* We need to have some Fill patterns for various places.  Here goes... */
  210. USHORT Pat_Normal[] = {  /** the normal filled pattern **/
  211.        0xffff,  /* plane 1 pattern */
  212.        0xffff,
  213.        0xffff,  /* plane 2 pattern */
  214.        0xffff  };
  215.  
  216. USHORT Pat_P1[] = {  /** first dithered filled pattern **/
  217.        0x5555,  /* plane 1 pattern */
  218.        0xaaaa,
  219.        0xffff,  /* plane 2 pattern */
  220.        0xffff  };
  221.  
  222. USHORT Pat_P2[] = {  /** second dithered filled pattern **/
  223.        0xffff,  /* plane 1 pattern */
  224.        0xffff,
  225.        0x5555,  /* plane 2 pattern */
  226.        0xaaaa   };
  227.  
  228. setHint(ShowHint)
  229. int ShowHint;
  230. {
  231.     char *s;
  232.     int  oldBPen;
  233.  
  234.     if (ShowHint) {
  235.        switch ( board[CurX][CurY][CurLevel].compass) {
  236.           case NORTH :   s = " HINT: Go North!                "; break;
  237.           case SOUTH :   s = " HINT: Go South!                "; break;
  238.           case EAST  :   s = " HINT: Go East!                 "; break;
  239.           case WEST  :   s = " HINT: Go West!                 "; break;
  240.           case SOLVED:   s = " CONGRATULATIONS!               "; break;
  241.           default    :   s = " Hmm.  I don't know.            "; break;
  242.           }
  243.        }
  244.       else {
  245.        s = " (Press Left Button for a hint.)";
  246.        }
  247.     Move(rp, 20L, 180L);
  248.     SetAPen(rp, 1L);
  249.     oldBPen = rp -> BgPen;
  250.     SetBPen(rp, 0L);
  251.     SetDrMd(rp, (LONG)JAM2);
  252.     Text(rp, s, 32L);
  253.     SetBPen(rp, (LONG)oldBPen);
  254.     }
  255.  
  256. showside(ax,ay, bx,by, cx,cy, dx,dy, color)
  257. LONG ax,ay, bx,by, cx,cy, dx,dy, color;
  258. {
  259.     SetAPen(  tmpRP, color);   /* The shape isn't allways a rect., so */
  260.     SetOPen(  tmpRP, color);   /*  we can't use RectFill() here...  */
  261.     BNDRYOFF( tmpRP);          /* Boundaries look bad w/ patterns...*/
  262.     switch (color) {
  263.        case CURPIECE     :
  264.        case TRAVERSED    : SetAfPt( tmpRP, Pat_P2,-1L); break;
  265.        case LASTPIECE    : SetAfPt( tmpRP, Pat_P1,-1L); break;
  266.        case NOTTRAVERSED :
  267.        case FIRSTPIECE   :
  268.        default           : SetAfPt( tmpRP, Pat_Normal,-1L); break;
  269.        }
  270.  
  271.     AreaMove( tmpRP, ax,ay);
  272.     AreaDraw( tmpRP, bx,by);
  273.     AreaDraw( tmpRP, cx,cy);
  274.     AreaDraw( tmpRP, dx,dy);
  275.     AreaEnd(  tmpRP);
  276.     SetAPen(  tmpRP, (LONG)EDGE);
  277.     Move(     tmpRP, ax,  ay);
  278.     Draw(     tmpRP, bx,  by);
  279.     Draw(     tmpRP, bx+1,by);
  280.     Draw(     tmpRP, ax+1,ay);
  281.     Move(     tmpRP, cx,  cy);
  282.     Draw(     tmpRP, dx,  dy);
  283.     Draw(     tmpRP, dx+1,dy);
  284.     Draw(     tmpRP, cx+1,cy);
  285.     }
  286.  
  287. putedge(ax,ay,bx,by)
  288. LONG ax,ay,bx,by;
  289. {
  290.     SetAPen(tmpRP,(LONG)EDGE);
  291.     Move(tmpRP,ax,  ay);
  292.     Draw(tmpRP,bx,  by);
  293.     Draw(tmpRP,bx+1,by);
  294.     Draw(tmpRP,ax+1,ay);
  295.     }
  296.  
  297. LONG renderColor(x, y, z, x1, y1, z1)
  298. int x, y, z, x1, y1, z1;
  299. {   int color;
  300.     color = board[x][y][z].inpath;
  301.     if (!(z == MaxLevel-1 && (color == FIRSTPIECE || color == LASTPIECE)))
  302.        if ((color == NOTTRAVERSED) ||
  303.            (board[x1][y1][z1].inpath == NOTTRAVERSED))
  304.            color = NOTTRAVERSED;
  305.     return((LONG)color);
  306.     }
  307.  
  308. #define XDIF 6
  309. #define YDIF 3
  310.  
  311. render(x,y)
  312. int x, y;
  313. {
  314.    LONG ax,ay, bx,by, cx,cy, dx,dy, color;
  315.    int level, Bleft, Btop, deltaX, deltaY, tmpL;
  316.    int left, right, bottom, top;
  317.  
  318.    /* clear the temporary bitmap */
  319.    SetAPen( tmpRP, 0L);
  320.    SetBPen( tmpRP, 0L);
  321.    RectFill( tmpRP, 0L, 0L, (LONG)SquareXsize, (LONG)SquareYsize );
  322.  
  323.    Bleft  =  4 + (x - 1) * SquareXsize;
  324.    Btop   = 11 + (y - 1) * SquareYsize;
  325.  
  326.    left   = 0;
  327.    right  = SquareXsize - 1;
  328.    top    = 0;
  329.    bottom = SquareYsize - 1;
  330.  
  331.    for (level=MinLevel; level<MaxLevel; level++) {
  332.        if (references(x, y, level) == 0)
  333.           continue; /* This level doesn't go anywhere. */
  334.  
  335.        deltaY = YDIF * level  + 1;
  336.        deltaX = XDIF * level  + 1;
  337.  
  338.        /**** Fill in the middle part first ****/
  339.        ax = right - deltaX;         ay = top + deltaY;
  340.        bx = left  + deltaX;         by = ay;
  341.        cx = bx;                     cy = bottom - deltaY;
  342.        dx = ax;                     dy = cy;
  343.        color = board[x][y][level].inpath;
  344.        showside(ax,ay,bx,by,cx,cy,dx,dy,color);
  345.  
  346.        /**** Do the NORTH side of this level first ****/
  347.        ax = right-deltaX;      ay = top + deltaY;
  348.        bx = ax;                by = top;
  349.        cx = left +deltaX;      cy = by;
  350.        dx = cx;                dy = ay;
  351.        tmpL  = board[x][y][level].conlev[NORTH];
  352.        if ( tmpL == NOWHERE) {
  353.             putedge(ax,ay,dx,dy);
  354.             goto DrawWest;
  355.             }
  356.        color = renderColor(x,y,level,x,y-1,tmpL);
  357.        if (tmpL != level && level == 1) {
  358.             bx = bx - XDIF*(tmpL - 1);
  359.             cx = cx + XDIF*(tmpL - 1);
  360.             }
  361.        showside(ax,ay,bx,by,cx,cy,dx,dy,color);
  362.  
  363.        /**** Do the WEST side of this level next ****/
  364.        DrawWest:
  365.        ax = left + deltaX;      ay = top + deltaY;
  366.        bx = left;               by = ay;
  367.        cx = bx;                 cy = bottom - deltaY;
  368.        dx = ax;                 dy = cy;
  369.        tmpL  = board[x][y][level].conlev[WEST];
  370.        if ( tmpL == NOWHERE) {
  371.             putedge(ax,ay,dx,dy);
  372.             goto DrawSouth;
  373.             }
  374.        color = renderColor(x,y,level,x-1,y,tmpL);
  375.        if (tmpL != level && level == 1) {
  376.             by = by + YDIF*(tmpL - 1);
  377.             cy = cy - YDIF*(tmpL - 1);
  378.             }
  379.        showside(ax,ay,bx,by,cx,cy,dx,dy,color);
  380.  
  381.        /**** Do the SOUTH side of this level next ****/
  382.        DrawSouth:
  383.        ax = left + deltaX;      ay = bottom - deltaY;
  384.        bx = ax;                 by = bottom;
  385.        cx = right - deltaX;     cy = by;
  386.        dx = cx;                 dy = ay;
  387.        tmpL  = board[x][y][level].conlev[SOUTH];
  388.        if ( tmpL == NOWHERE) {
  389.             putedge(ax,ay,dx,dy);
  390.             goto DrawEast;
  391.             }
  392.        color = renderColor(x,y,level,x,y+1,tmpL);
  393.        if (tmpL != level && level == 1) {
  394.             bx = bx + XDIF*(tmpL-1);
  395.             cx = cx - XDIF*(tmpL-1);
  396.             }
  397.        showside(ax,ay,bx,by,cx,cy,dx,dy,color);
  398.  
  399.        /**** Do the EAST side of this level last ****/
  400.        DrawEast:
  401.        ax = right - deltaX;     ay = bottom - deltaY;
  402.        bx = right;              by = ay;
  403.        cx = bx;                 cy = top + deltaY;
  404.        dx = ax;                 dy = cy;
  405.        tmpL  = board[x][y][level].conlev[EAST];
  406.        if ( tmpL == NOWHERE) {
  407.             putedge(ax,ay,dx,dy);
  408.             goto DrawComplete;
  409.             }
  410.        color = renderColor(x,y,level,x+1,y,tmpL);
  411.        if (tmpL != level && level == 1) {
  412.             by = by - YDIF*(tmpL - 1);
  413.             cy = cy + YDIF*(tmpL - 1);
  414.             }
  415.        showside(ax,ay,bx,by,cx,cy,dx,dy,color);
  416.        DrawComplete:;
  417.        }
  418.    /* now copy temporary bitmap into window */
  419.  
  420.    BltBitMapRastPort(&tmpBM,0L,0L, rp,(LONG)Bleft,(LONG)Btop,
  421.             (LONG)SquareXsize,(LONG)SquareYsize, (LONG)0x0c0);
  422.    }  /* end of render() */
  423.  
  424.  
  425. /* references() returns the number connections from a given square. */
  426. int references(x, y, level)
  427. int x, y, level;
  428. { int i, refs;
  429.     refs = 0;
  430.     for (i=0; i < DIRECTIONS; i++)
  431.         if (board[x][y][level].conlev[i] != NOWHERE)
  432.             refs++;
  433.     return(refs);
  434.     }
  435.  
  436. /* linkable() returns true if we can connect the two indicated squares. */
  437. /* NOTE: We don't allow connecting to the second square if it */
  438. /* is already part of the maze.  This test if the first if stmt.*/
  439. /* The second test if more subtle.  The problem being tested for is shown in */
  440. /* the following diagram.  This is an edge-on view of the board: */
  441. /*   a __    __ d   */
  442. /*       \  /       */
  443. /*         /        */
  444. /*        /         */
  445. /*   c __/  \__ b   */
  446. /* If c and d are connected, I can't connect a to b because the paths would */
  447. /* intersect.  The way the test is written, it will work regardless of whether 
  448. /
  449. /* the new path is going up, down, or level. */
  450.  
  451. int linkable(x1,y1,level1,dir1, x2,y2, level2, dir2)
  452. int x1,y1,level1,dir1, x2,y2,level2;
  453. {
  454.    int tmp;
  455.    if (references(x2,y2,level2)) return(0);
  456.    if (board[x1][y1][level2].conlev[dir1] == level1) return(0);
  457.    return(-1);
  458.    }
  459.  
  460. /* Returns the other Direction, or NOWHERE if an invalid direction is passed. *
  461.  
  462. int otherDir(nd)
  463. int nd;
  464. { switch (nd) {
  465.     case NORTH : return(SOUTH); break;
  466.     case SOUTH : return(NORTH); break;
  467.     case EAST  : return(WEST) ; break;
  468.     case WEST  : return(EAST) ; break;
  469.     }
  470.   return(NOWHERE);
  471.   }
  472.  
  473.  
  474. /* makepathlist() returns the number of directions we can go from here w/o */
  475. /*  backtracking -- i.e., not counting the way we got here.  These */
  476. /*  "uncharted" routes are characterized by .compus==NOWHERE.  The list of */
  477. /*  directions is placed in pl[]. */
  478.  
  479. int makepathlist(x,y,z,pl)
  480. int x, y, z, pl[];
  481. {   int di, le, paths;
  482.     paths = 0;
  483.     for (di=0; di<DIRECTIONS; di++) {
  484.         pl[paths] = di;
  485.         le = board[x][y][z].conlev[di];
  486.         if (le != NOWHERE)
  487.            switch (di) {
  488.               case NORTH   :  if (board[x][y-1][le].compass == NOWHERE)
  489.                                  paths++;
  490.                               break;
  491.               case SOUTH   :  if (board[x][y+1][le].compass == NOWHERE)
  492.                                  paths++;
  493.                               break;
  494.               case EAST    :  if (board[x+1][y][le].compass == NOWHERE)
  495.                                  paths++;
  496.                               break;
  497.               case WEST    :  if (board[x-1][y][le].compass == NOWHERE)
  498.                                  paths++;
  499.                               break;
  500.               case NOWHERE :  break;
  501.               }
  502.         }
  503.     return(paths);
  504.     }
  505.  
  506. int topscore;
  507.  
  508. /* buildreturnmap() is a recursive routine which starts the end of a path on */
  509. /* our tree-structured maze and traverses up to an intersection or dead end. */
  510. /* When we hit a dead end, we just return, but when we hit an intersection, we 
  511. /
  512. /* call buildreturnmap() again, once for each path going off from the */
  513. /* intersection, except for the one got there on.  We keep a score for how far 
  514. /
  515. /* we are from the first square.  One point per square, plus 5 times the */
  516. /* number of paths leading off from each intersection.  We keep a topscore to *
  517.  
  518. /* find out which square is farthest (in this modified sense) from our */
  519. /* starting square.  This helps to ensure that we get a reasonably difficult */
  520. /* maze to solve. */
  521. /*   We also record the direction to the end of the maze in each square.  This 
  522. /
  523. /* information is used by the hint facility. */
  524.  
  525. buildreturnmap(x,y,z,score)
  526. int x, y, z, score;
  527. {   int pathlist[DIRECTIONS], paths, i, le;
  528.  
  529.     while ( (paths = makepathlist(x,y,z,pathlist)) == 1) {
  530.           z = board[x][y][z].conlev[pathlist[0]];
  531.           switch (pathlist[0]) {
  532.             case NORTH : y--; break;
  533.             case SOUTH : y++; break;
  534.             case EAST  : x++; break;
  535.             case WEST  : x--; break;
  536.             }
  537.           board[x][y][z].compass = otherDir(pathlist[0]);
  538.           /* score++; */
  539.           }
  540.  
  541.     if (paths == 0) {   /* We are at the end of a path... */
  542.         if (score >= topscore) {
  543.             topscore = score;
  544.             StartX = x;
  545.             StartY = y;
  546.             StartLevel = z;
  547.             }
  548.         return;
  549.         }
  550.  
  551.     /* if we got here, we are not at the end of a path.   paths > 1 */
  552.     score = score + paths;
  553.  
  554.     for (i=0; i<paths; i++) {
  555.         le = board[x][y][z].conlev[pathlist[i]];
  556.         switch (pathlist[i]) {
  557.            case NORTH   : board[x][y-1][le].compass = SOUTH;
  558.                           buildreturnmap(x,y-1,le,score);     break;
  559.  
  560.            case SOUTH   : board[x][y+1][le].compass = NORTH;
  561.                           buildreturnmap(x,y+1,le,score);     break;
  562.  
  563.            case EAST    : board[x+1][y][le].compass = WEST;
  564.                           buildreturnmap(x+1,y,le,score);     break;
  565.  
  566.            case WEST    : board[x-1][y][le].compass = EAST;
  567.                           buildreturnmap(x-1,y,le,score);     break;
  568.            }
  569.         }
  570.     }
  571.  
  572. #define MAXENDS 120
  573. #define FREEEND -1
  574. #define LASTEND -1
  575. typedef struct {
  576.         int x,y,z;    /* board coordinates. x=FREEEND means this one is free */
  577.         int prevdir;  /* The direction we went to get here. */
  578.                       /*    In picking what direction to go, we are biased */
  579.                       /*    toward this direction.  This gives paths */
  580.                       /*    with several straight sections -- keeps one path fr
  581. m */
  582.                       /*    knotting up one part of the board. */
  583.         int nextfree; /* next unused end, LASTEND means no more  */
  584.         } endtype;
  585.  
  586. endtype ends[MAXENDS];
  587. int     firstfree;
  588. int     MaxEnds = MAXENDS;
  589.  
  590. initends()
  591. {   int i;
  592.  
  593.     for (i=0; i<MaxEnds; i++) {
  594.         ends[i].x = -1;
  595.         ends[i].y = -1;
  596.         ends[i].z = -1;
  597.         ends[i].nextfree = i - 1;
  598.         }
  599.     firstfree = MaxEnds - 1;
  600.     /* NOTE that ends[0].nextfree == -1 == LASTEND.  If that define ever */
  601.     /* changes, we will have to include the statement: */
  602.     /* ends[0].nextfree = LASTEND; */
  603.     }
  604.  
  605. /* IF you want to play around with the parameters that effect the way
  606.    boards are built, you will want to try different combinations of
  607.    "tries", "length", and global MaxEnds. */
  608.  
  609. int extendend(curend,tries,length)
  610. int curend, tries, length;
  611. {
  612.     int x, y, level;
  613.     int nd,od, nx, ny, nl, i, moves, link;
  614.  
  615.     moves = 0;
  616.  
  617.     x     = ends[curend].x;
  618.     y     = ends[curend].y;
  619.     level = ends[curend].z;
  620.     nd    = ends[curend].prevdir;
  621.  
  622.     /* try up to i times to add a random square */
  623.     for (i=0; i<tries && moves < length; i++) {
  624.         do {         /*  try not to go out of bounds */
  625.              nd = ((RangeRand(10L) < 4) ? (int)RangeRand((LONG)DIRECTIONS) : nd
  626. ;
  627.              } while ((nd == NORTH && y == 1)           ||
  628.                       (nd == WEST  && x == 1)           ||
  629.                       (nd == SOUTH && y == BoardMaxY-1) ||
  630.                       (nd == EAST  && x == BoardMaxX-1)     );
  631.         /* Now that we've got a direction, see that we don't already go that wa
  632.  */
  633.         if (board[x][y][level].conlev[nd] != NOWHERE)
  634.             continue;
  635.         nx = x;  ny = y;
  636.         switch (nd) {                /* work out the new x and y */
  637.             case NORTH : ny = y - 1; break;
  638.             case SOUTH : ny = y + 1; break;
  639.             case EAST  : nx = x + 1; break;
  640.             case WEST  : nx = x - 1; break;
  641.             }
  642.         od = otherDir(nd);
  643.         nl = level;
  644.  
  645.         /** get some level we can go onto from here **/
  646.         if (!(link=linkable(x, y, level, nd, nx, ny, nl, od))) {   /* stay on t
  647. e same level if we can... */
  648.            if (level > MinLevel) {    /* can't stay on this level so go down */
  649.                nl = level - 1;
  650.                link = linkable(x, y, level, nd, nx, ny, nl, od); /* if we can't
  651. go down, go up */
  652.                }
  653.            if (!link && (level < MaxLevel - 1)) {
  654.                nl = level + 1;   /* can't go down or level, so try up */
  655.                link = linkable(x, y, level, nd, nx, ny, nl, od);
  656.                }
  657.            }
  658.  
  659.         if (link) {
  660.             board[x ][y ][level].conlev[nd] = nl;
  661.             board[nx][ny][nl   ].conlev[od] = level;
  662.             render( x, y);
  663.             render(nx,ny);
  664.             moves++;
  665.             /* sometimes fork, putting our old coordinates in a free end slot. 
  666. /
  667.             if (firstfree != LASTEND) {  /* make sure there IS a free end slot 
  668. /
  669.                 if (RangeRand(10L) < 4) {
  670.                    ends[firstfree].x = x;
  671.                    ends[firstfree].y = y;
  672.                    ends[firstfree].z = level;
  673.                    ends[firstfree].prevdir = nd;
  674.                    firstfree = ends[firstfree].nextfree;
  675.                    }
  676.                 }
  677.             ends[curend].x = x     = nx;
  678.             ends[curend].y = y     = ny;
  679.             ends[curend].z = level = nl;
  680.             }
  681.         }
  682.     /* if we got this far and made no moves, we are probably on dead end and */
  683.     /* should put this ends[] on the free list. */
  684.     if (moves == 0) {
  685.           ends[curend].x = FREEEND;
  686.           ends[curend].nextfree = firstfree;
  687.           firstfree = curend;
  688.           }
  689.     return(moves);
  690.     }
  691. int xties, xlength;
  692. int makepath()
  693. {   int i, endsfound, totalsquares;
  694.  
  695.     initends();   /* This sets the table of path ends to all zeros */
  696.  
  697.     /*   ends[] is a list of the ends of paths which we can add more paths */
  698.     /*   onto.  Note that they don't really have to be an end; they can be */
  699.     /*   in the middle of a path as well.   Not all of them are in use as */
  700.     /*   an end all the time.  Some are in a linked list of "free" ends, */
  701.     /*   available for use if we want to add an end.  Free (unused) array */
  702.     /*   elements are marked by a .x == FREEEND.  Ends get taken out of active 
  703. /
  704.     /*   service and put on the free list when the path generator "extendend()"
  705. */
  706.     /*   fails to extend the path from that end.  When no active ends remain, *
  707.  
  708.     /*   maze generation terminates. */
  709.  
  710.     /*  p.s.: I don't particularly care for the mazes that are generated by */
  711.     /*  this method, nor am I particularly fond of the method.  I would like */
  712.     /*  to hear of other strategies for maze generation. */
  713.  
  714.  
  715.     ends[firstfree].x = 1 + RangeRand((LONG)BoardMaxX - 1);
  716.     ends[firstfree].y = 1 + RangeRand((LONG)BoardMaxY - 1);
  717.     ends[firstfree].z = 0;
  718.     ends[firstfree].prevdir = RangeRand((LONG)DIRECTIONS);
  719.     firstfree = ends[firstfree].nextfree;
  720.  
  721.     totalsquares = 0;
  722.     do {
  723.          endsfound = 0;
  724.          for (i=0; i< MaxEnds; i++) {
  725.              if (ends[i].x != FREEEND) {
  726.                     endsfound++;
  727.                     totalsquares += extendend(i,xties,xlength);
  728.                     }
  729.              }
  730.          } while (endsfound);
  731.     return( totalsquares );
  732.     }
  733.  
  734. pickends()
  735. {   int x, y, z, i;
  736.  
  737.     /* Find then end of a path on the bottom level. */
  738.     do {
  739.         StartX = 1 + RangeRand( (LONG) BoardMaxX-1L );
  740.         StartY = 1 + RangeRand( (LONG) BoardMaxY-1L );
  741.         StartLevel =  MinLevel;
  742.         } while (references( StartX, StartY, StartLevel) != 1);
  743.  
  744.     /* The reason for doing this 4 times is to make the ends as far apart as */
  745.     /* possible.  If our first choice is close to the top of the tree, it */
  746.     /* can't be very far away from every leaf node.  The way this works is: */
  747.     /*     1  Find a leaf node. */
  748.     /*     2  Find the leaf farthest from the one found in step 1. */
  749.     /*     3  Find the leaf farthest from the one found in step 2. ... */
  750.     /* Eventually you should end up with two good choices for the ends. */
  751.  
  752.     for (i=0; i<4; i++) {
  753.         for (x=1; x<BoardMaxX; x++)
  754.             for (y=1; y<BoardMaxY; y++)
  755.                 for (z=MinLevel; z<MaxLevel; z++)
  756.                     board[x][y][z].compass = NOWHERE;
  757.  
  758.         EndX = StartX;   EndY = StartY;    EndLevel = StartLevel;
  759.         board[ EndX ][ EndY ][ EndLevel ].compass = SOLVED;
  760.         topscore = 0;
  761.         buildreturnmap(EndX, EndY, EndLevel, 0);
  762.         }
  763.  
  764.     board[ StartX ][ StartY ][ StartLevel ].inpath = FIRSTPIECE;
  765.     board[ EndX   ][ EndY   ][ EndLevel   ].inpath = LASTPIECE;
  766.     CurX     = StartX;
  767.     CurY     = StartY;
  768.     CurLevel = StartLevel;
  769.     NewX     = CurX;
  770.     NewY     = CurY;
  771.     NewLevel = CurLevel;
  772.     render( StartX, StartY);
  773.     render( EndX,   EndY);
  774.     }
  775.  
  776. init1( l )
  777. int l;
  778. {
  779.   int i, x, y, level, dir;
  780.   static int Xsize[] = { 54, 16, 24, 34 }; /* Square widths  */
  781.   static int Xsqrs[] = { 10, 34, 22, 16 }; /* No. of squares */
  782.  
  783.   static int Ysize[] = { 26, 10, 14, 18 }; /* Square heights */
  784.   static int Ysqrs[] = {  6, 16, 11,  9 }; /* No. of squares */
  785.  
  786.      /* Reset the entire board, including a strip of squares around */
  787.      /* the edges that we never go into. */
  788.   for(x=0; x <= BOARDMAXX; x++)
  789.      for(y=0; y <= BOARDMAXY; y++)
  790.         for(level=0; level < MAXLEVELS; level++) {
  791.            board[x][y][level].inpath   =  NOTTRAVERSED;
  792.            board[x][y][level].compass  =  NOWHERE;
  793.            for(dir=0; dir < DIRECTIONS; dir++)
  794.               board[x][y][level].conlev[dir] =  NOWHERE;
  795.            }
  796.  
  797.   SetAPen( rp, 0L);
  798.   SetBPen( rp, 0L);
  799.   RectFill( rp, 4L, 11L, (LONG)windowW-4, (LONG)windowH-2);
  800.  
  801.   MaxLevel = l;   /* l==0 is a special-case first-time super-easy 1-level */
  802.                   /* maze.  It generates fast so we can get to the menus. */
  803.  
  804.   BoardMaxX   = Xsqrs[ MaxLevel ] + 1;
  805.   SquareXsize = Xsize[ MaxLevel ];
  806.   BoardMaxY   = Ysqrs[ MaxLevel ] + 1;
  807.   SquareYsize = Ysize[ MaxLevel ];
  808.  
  809.   if (MaxLevel == 0)
  810.      MaxLevel = 1;
  811.  
  812.   makepath();
  813.  
  814.   pickends();
  815.   setHint( (int)FALSE );
  816.   }
  817.  
  818. int autosolve()
  819. {   int newDir;
  820.     square *oldSq, *newSq;
  821.  
  822.     while ( (newDir = board[CurX][CurY][CurLevel].compass) != SOLVED ) {
  823.           NewX = CurX;
  824.           NewY = CurY;
  825.           NewLevel = board[CurX][CurY][CurLevel].conlev[newDir];
  826.           switch (newDir) {
  827.               case NORTH : NewY--; break;
  828.               case SOUTH : NewY++; break;
  829.               case EAST  : NewX++; break;
  830.               case WEST  : NewX--; break;
  831.               }
  832.  
  833.           oldSq = &board[ CurX ][ CurY ][ CurLevel];
  834.           newSq = &board[ NewX ][ NewY ][ NewLevel];
  835.  
  836.           oldSq->inpath = TRAVERSED;
  837.  
  838.           switch (newSq->inpath) {
  839.               case TRAVERSED  :
  840.               case FIRSTPIECE : /* We must have backed up to get here, so...*/
  841.                           oldSq->inpath = NOTTRAVERSED; break;
  842.               default         : ;
  843.               }
  844.  
  845.           /* set the inpath flag of the new square in any case */
  846.           newSq->inpath = CURPIECE;
  847.  
  848.           /* Also, just in case we backed up to the starting square */
  849.           /*   or from the ending square.... */
  850.           board[StartX][StartY][StartLevel].inpath = FIRSTPIECE;
  851.           board[EndX  ][EndY  ][EndLevel  ].inpath = LASTPIECE;
  852.  
  853.           /* Now draw both squares */
  854.           render(CurX,CurY);
  855.           render(NewX,NewY);
  856.  
  857.           /* Now new becomes current */
  858.           CurX = NewX;
  859.           CurY = NewY;
  860.           CurLevel = NewLevel;
  861.  
  862.           }
  863.     }
  864.  
  865.  
  866.  
  867. int mousewatch()
  868. {   static int canmove = FALSE;
  869.     int x, y, newDir;
  870.  
  871.     x = ((MouseX) -  4)/SquareXsize + 1;
  872.     y = ((MouseY) - 11)/SquareYsize + 1;
  873.  
  874.     x = x * SIGN(MouseX);
  875.     y = y * SIGN(MouseY);
  876.  
  877.     if (x == CurX && y == CurY) {
  878.         canmove = TRUE;
  879.         }
  880.  
  881.     newDir = NOWHERE;
  882.     if (x == CurX) {
  883.          if (y == CurY + 1 && y < BoardMaxY)
  884.                newDir = SOUTH;
  885.             else if (y == CurY - 1 && y > 0)
  886.                       newDir = NORTH;
  887.          }
  888.       else
  889.          if (y == CurY) {
  890.                if (x == CurX + 1 && x < BoardMaxX)
  891.                      newDir = EAST;
  892.                   else if (x == CurX - 1 && x > 0)
  893.                            newDir = WEST;
  894.              }
  895.  
  896.     if (newDir == NOWHERE ) {
  897.          canmove = FALSE;
  898.          return(NOWHERE);
  899.          }
  900.  
  901.     NewLevel = board[CurX][CurY][CurLevel].conlev[newDir];
  902.  
  903.     if (NewLevel == NOWHERE) {
  904.        canmove = FALSE;
  905.        return(NOWHERE);
  906.        }
  907.     NewX = x;
  908.     NewY = y;
  909.     return(newDir);
  910.     }
  911.  
  912. int trymove() /* returns TRUE if we won, FALSE if we didn't win. */
  913. {   int newDir;
  914.     square *oldSq, *newSq;
  915.  
  916.     newDir = mousewatch();
  917.     if (newDir == NOWHERE)
  918.        return(board[CurX][CurY][CurLevel].compass == SOLVED);
  919.  
  920.     oldSq = &board[ CurX ][ CurY ][ CurLevel];
  921.     newSq = &board[ NewX ][ NewY ][ NewLevel];
  922.  
  923.     oldSq->inpath = TRAVERSED;
  924.     switch (newSq->inpath) {
  925.         case TRAVERSED  :
  926.         case FIRSTPIECE : /* We must have backed up to get here, so...*/
  927.                           oldSq->inpath = NOTTRAVERSED; break;
  928.         default         : ;
  929.         }
  930.  
  931.     /* set the inpath flag of the new square in any case */
  932.     newSq->inpath = CURPIECE;
  933.  
  934.     /* Also, just in case we backed up from the starting square */
  935.     /*   or the ending square.... */
  936.     board[StartX][StartY][StartLevel].inpath = FIRSTPIECE;
  937.     board[EndX  ][EndY  ][EndLevel  ].inpath = LASTPIECE;
  938.  
  939.     /* Now draw both squares */
  940.     render(CurX,CurY);
  941.     render(NewX,NewY);
  942.  
  943.     /* Now new becomes current */
  944.     CurX = NewX;
  945.     CurY = NewY;
  946.     CurLevel = NewLevel;
  947.  
  948.     /* ?did we win? */
  949.  
  950.     setHint((int)(newSq->compass == SOLVED));
  951.  
  952.     if (newSq->compass == SOLVED) {
  953.           cycle( 3 );
  954.           return( (int)TRUE );
  955.           }
  956.     return( (int)FALSE);
  957.     }
  958.  
  959. HandleMenu(menucode)
  960. USHORT menucode;
  961. {
  962.     ModifyIDCMP( window, (ULONG) MIDCMP2 );
  963.  
  964.     switch ( ITEMNUM( menucode) ) {
  965.         case 0 : about()   ;  break;
  966.         case 1 : init1( 1 );  break;
  967.         case 2 : init1( 2 );  break;
  968.         case 3 : init1( 3 );  break;
  969.         case 4 : autosolve(); break;
  970.         }
  971.  
  972.     ModifyIDCMP( window, (ULONG) MIDCMP1 );
  973.     }
  974.  
  975.  
  976. EventLoop()
  977. {
  978.   struct IntuiMessage *mesg;
  979.   ULONG  class, code, mousemoved, closewindow, menupick;
  980.   USHORT menucode;
  981.  
  982.   closewindow = FALSE;
  983.   ModifyIDCMP( window, (ULONG) MIDCMP1 );
  984.  
  985.   do {
  986.        mousemoved = FALSE;
  987.        menupick   = FALSE;
  988.  
  989.        Wait( (LONG) 1 << window -> UserPort -> mp_SigBit);
  990.  
  991.        while ((mesg=(struct IntuiMessage *)GetMsg(window->UserPort))) {
  992.              class = mesg->Class;
  993.              code  = mesg->Code;
  994.              MouseX = mesg->MouseX;
  995.              MouseY = mesg->MouseY;
  996.              ReplyMsg(mesg);
  997.              if (class == MOUSEMOVE) mousemoved = TRUE;
  998.              if (class == CLOSEWINDOW) closewindow = TRUE;
  999.              if (class == MOUSEBUTTONS && code == SELECTDOWN)
  1000.                 setHint( (int) TRUE);
  1001.              if (class == MENUPICK) {
  1002.                 menupick = TRUE;
  1003.                 menucode = code;
  1004.                 }
  1005.              }
  1006.        if (mousemoved) trymove();
  1007.        if (menupick)   HandleMenu(menucode);
  1008.        } while (closewindow == FALSE);
  1009.   }
  1010.  
  1011. struct TextFont *textfont = NULL;
  1012.  
  1013. openstuff()
  1014. {   ULONG Seconds, Micros;
  1015.  
  1016.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0L)
  1017.  
  1018.     if (IntuitionBase == NULL) {closestuff(); exit(0);}
  1019.  
  1020.     GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",0L);
  1021.     if (GfxBase == NULL) {closestuff(); exit(0); }
  1022.  
  1023.     /* My <functions.h> shows OpenFont() returns a *Font. */
  1024.     /* I think that is an error! */
  1025.  
  1026.     textfont = (struct TextFont *)OpenFont( &font );
  1027.     if (textfont==NULL) { closestuff(); exit(0); }
  1028.  
  1029.     if (( window=(struct Window *)OpenWindow(&nw))==NULL) {
  1030.        closestuff();
  1031.        exit(0);
  1032.        }
  1033.     if (SetFont(window->RPort,textfont)==0) { closestuff(); exit(0); }
  1034.  
  1035.     SetWindowTitles(window,(UBYTE *)" TML's AmigaMaze     ver. 1.2 ",
  1036.             (UBYTE *)"TML's AmigaMaze       First distributed on JUMPDISK.");
  1037.  
  1038.     SetMenuStrip( window, &menu);
  1039.  
  1040.     /*  This next bit is a cludge because I can't seem to get */
  1041.     /*                 extern ULONG RangeSeed; */
  1042.     /*      to work.  Anyone got any ideas? */
  1043.     /*  LATER: It turns out that the RangeSeed is not public */
  1044.     /*      in the Manx sources.  Hope they fix this someday. */
  1045.     CurrentTime(&Seconds,&Micros);
  1046.     Micros = Micros & (ULONG) 0x0fff;
  1047.     for (Seconds=0; Seconds < Micros; Seconds++)
  1048.          RangeRand(4L);
  1049.     }
  1050.  
  1051.  
  1052. closestuff()
  1053. {   int i;
  1054.     for(i=0; i<2; i++) {
  1055.        if (tmpBM.Planes[i])
  1056.             FreeRaster(tmpBM.Planes[i],tmpBMxy,tmpBMxy);
  1057.        }
  1058.     if (window) {
  1059.         ClearMenuStrip( window );
  1060.         CloseWindow(window);
  1061.         }
  1062.     if (textfont) CloseFont(textfont);
  1063.     if (GfxBase) CloseLibrary(GfxBase);
  1064.     if (IntuitionBase) CloseLibrary(IntuitionBase);
  1065.     }
  1066.  
  1067. main(/*argc,argv*/)
  1068. /* int argc; */
  1069. /* char *argv[]; */
  1070. {   UWORD areabuffer[250], areabuffer2[250];
  1071.     struct TmpRas   tmpras,   tmprasB;
  1072.     struct AreaInfo areainfo, areainfo2;
  1073.     PLANEPTR plane,planeB;
  1074.     int i;
  1075.  
  1076.     /* if (argc > 1) */
  1077.     /*     xties = atoi(argv[1]); */
  1078.     /* if (xties < 1 || xties > 100) */
  1079.         xties = 30;
  1080.  
  1081.     /* if (argc > 2) */
  1082.     /*     xlength = atoi(argv[2]); */
  1083.     /* if (xlength < 1 || xlength > 100) */
  1084.         xlength = 9;
  1085.  
  1086.     /* if (argc > 3) */
  1087.     /*     MaxEnds = atoi(argv[3]); */
  1088.     /* if (MaxEnds < 2 || MaxEnds > MAXENDS) */
  1089.         MaxEnds = MAXENDS;
  1090.  
  1091.     MaxLevel = 1;
  1092.     MinLevel = 0;
  1093.     openstuff();
  1094.     InitBitMap( &tmpBM, 2L, tmpBMxy, tmpBMxy );
  1095.     for (i=0; i<2; i++) {
  1096.          if ((tmpBM.Planes[i] = (PLANEPTR)AllocRaster(tmpBMxy,tmpBMxy))==NULL) 
  1097.  
  1098.              closestuff();
  1099.              exit(0);
  1100.              }
  1101.          }
  1102.     rp = window->RPort;
  1103.     if ((plane = AllocRaster(windowW,windowH))==NULL) {
  1104.         closestuff();
  1105.         exit(0);
  1106.         }
  1107.     if ((planeB = AllocRaster(tmpBMxy,tmpBMxy))==NULL) {
  1108.         FreeRaster(plane, windowW,windowH);
  1109.         closestuff();
  1110.         exit(0);
  1111.         }
  1112.     InitArea(&areainfo, areabuffer, 90L);
  1113.     InitArea(&areainfo2,areabuffer2,90L);
  1114.  
  1115.     InitTmpRas(&tmpras, plane, RASSIZE( windowW, windowH));
  1116.     InitTmpRas(&tmprasB,planeB,RASSIZE( tmpBMxy, tmpBMxy));
  1117.  
  1118.     rp->AreaInfo    = &areainfo;
  1119.     rp->TmpRas      = &tmpras;
  1120.  
  1121.     InitRastPort( tmpRP );
  1122.     if (SetFont(tmpRP,textfont)==0) { closestuff(); exit(0); }
  1123.     tmpRP->BitMap = &tmpBM;
  1124.     tmpRP->AreaInfo = &areainfo2;
  1125.     tmpRP->TmpRas   = &tmprasB;
  1126.  
  1127.     init1(0); /* Zero is a special case.  Super simple fast easy maze
  1128.                  so the user can get to the menus w/o waiting so long. */
  1129.     ModifyIDCMP( window, (ULONG) MIDCMP2 );
  1130.     about();
  1131.     EventLoop();
  1132.     FreeRaster(plane, windowW, windowH);
  1133.     FreeRaster(planeB,tmpBMxy, tmpBMxy);
  1134.     closestuff();
  1135.     }
  1136.  
  1137. /* Save some code space by stubbing _wb_parse() and _cli_parse(). */
  1138. void _wb_parse()
  1139. { }
  1140.  
  1141. void _cli_parse()
  1142. { }
  1143.  
  1144.